home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 4: GNU Archives / Linux Cubed Series 4 - GNU Archives.iso / gnu / binutils.7 / binutils / binutils-2.7 / bfd / evax-alpha.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-04  |  47.9 KB  |  1,858 lines
  1. /* evax-alpha.c -- BFD back-end for ALPHA EVAX (openVMS/AXP) files.
  2.    Copyright 1996 Free Software Foundation, Inc.
  3.    Written by Klaus KΣmpf (kkaempf@progis.de)
  4.    of proGIS Softwareentwicklung, Aachen, Germany
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19.  
  20.  
  21. #include <stdio.h>
  22.  
  23. #include "bfd.h"
  24. #include "sysdep.h"
  25. #include "bfdlink.h"
  26. #include "libbfd.h"
  27.  
  28. #include "evax.h"
  29.  
  30. static boolean evax_initialize PARAMS ((bfd *));
  31. static boolean fill_section_ptr PARAMS ((struct bfd_hash_entry *, PTR));
  32. static boolean evax_fixup_sections PARAMS ((bfd *));
  33. static boolean copy_symbols PARAMS ((struct bfd_hash_entry *, PTR));
  34. static bfd_reloc_status_type reloc_nil
  35.   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  36. static const struct bfd_target *evax_object_p PARAMS ((bfd *abfd));
  37. static const struct bfd_target *evax_archive_p PARAMS ((bfd *abfd));
  38. static boolean evax_mkobject PARAMS ((bfd *abfd));
  39. static boolean evax_write_object_contents PARAMS ((bfd *abfd));
  40. static boolean evax_close_and_cleanup PARAMS ((bfd *abfd));
  41. static boolean evax_bfd_free_cached_info PARAMS ((bfd *abfd));
  42. static boolean evax_new_section_hook PARAMS ((bfd *abfd, asection *section));
  43. static boolean evax_get_section_contents
  44.   PARAMS ((bfd *abfd, asection *section, PTR x1, file_ptr x2,
  45.        bfd_size_type x3));
  46. static boolean evax_get_section_contents_in_window
  47.   PARAMS ((bfd *abfd, asection *section, bfd_window *w, file_ptr offset,
  48.        bfd_size_type count));
  49. static boolean evax_bfd_copy_private_bfd_data PARAMS ((bfd *src, bfd *dest));
  50. static boolean evax_bfd_copy_private_section_data
  51.   PARAMS ((bfd *srcbfd, asection *srcsec, bfd *dstbfd, asection *dstsec));
  52. static boolean evax_bfd_copy_private_symbol_data
  53.   PARAMS ((bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym));
  54. static boolean evax_bfd_print_private_bfd_data
  55.   PARAMS ((bfd *abfd, void *file));
  56. static char *evax_core_file_failing_command PARAMS ((bfd *abfd));
  57. static int evax_core_file_failing_signal PARAMS ((bfd *abfd));
  58. static boolean evax_core_file_matches_executable_p
  59.   PARAMS ((bfd *abfd, bfd *bbfd));
  60. static boolean evax_slurp_armap PARAMS ((bfd *abfd));
  61. static boolean evax_slurp_extended_name_table PARAMS ((bfd *abfd));
  62. static boolean evax_construct_extended_name_table
  63.   PARAMS ((bfd *abfd, char **tabloc, bfd_size_type *tablen,
  64.        const char **name));
  65. static void evax_truncate_arname
  66.   PARAMS ((bfd *abfd, CONST char *pathname, char *arhdr));
  67. static boolean evax_write_armap
  68.   PARAMS ((bfd *arch, unsigned int elength, struct orl *map,
  69.        unsigned int orl_count, int stridx));
  70. static PTR evax_read_ar_hdr PARAMS ((bfd *abfd));
  71. static bfd *evax_get_elt_at_index PARAMS ((bfd *abfd, symindex index));
  72. static bfd *evax_openr_next_archived_file PARAMS ((bfd *arch, bfd *prev));
  73. static boolean evax_update_armap_timestamp PARAMS ((bfd *abfd));
  74. static int evax_generic_stat_arch_elt PARAMS ((bfd *abfd, struct stat *stat));
  75. static long evax_get_symtab_upper_bound PARAMS ((bfd *abfd));
  76. static long evax_get_symtab PARAMS ((bfd *abfd, asymbol **symbols));
  77. static void evax_print_symbol
  78.   PARAMS ((bfd *abfd, PTR file, asymbol *symbol, bfd_print_symbol_type how));
  79. static void evax_get_symbol_info
  80.   PARAMS ((bfd *abfd, asymbol *symbol, symbol_info *ret));
  81. static boolean evax_bfd_is_local_label PARAMS ((bfd *abfd, asymbol *symbol));
  82. static alent *evax_get_lineno PARAMS ((bfd *abfd, asymbol *symbol));
  83. static boolean evax_find_nearest_line
  84.   PARAMS ((bfd *abfd, asection *section, asymbol **symbols, bfd_vma offset,
  85.        const char **file, const char **func, unsigned int *line));
  86. static asymbol *evax_bfd_make_debug_symbol
  87.   PARAMS ((bfd *abfd, void *ptr, unsigned long size));
  88. static long evax_read_minisymbols
  89.   PARAMS ((bfd *abfd, boolean dynamic, PTR *minisymsp, unsigned int *sizep));
  90. static asymbol *evax_minisymbol_to_symbol
  91.   PARAMS ((bfd *abfd, boolean dynamic, const PTR minisym, asymbol *sym));
  92. static long evax_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect));
  93. static long evax_canonicalize_reloc
  94.   PARAMS ((bfd *abfd, asection *srcsec, arelent **location,
  95.        asymbol **symbols));
  96. static const struct reloc_howto_struct *evax_bfd_reloc_type_lookup
  97.   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
  98. static boolean evax_set_arch_mach
  99.   PARAMS ((bfd *abfd, enum bfd_architecture arch, unsigned long mach));
  100. static boolean evax_set_section_contents
  101.   PARAMS ((bfd *abfd, asection *section, PTR location, file_ptr offset,
  102.        bfd_size_type count));
  103. static int evax_sizeof_headers PARAMS ((bfd *abfd, boolean reloc));
  104. static bfd_byte *evax_bfd_get_relocated_section_contents
  105.   PARAMS ((bfd *abfd, struct bfd_link_info *link_info,
  106.        struct bfd_link_order *link_order, bfd_byte *data,
  107.        boolean relocateable, asymbol **symbols));
  108. static boolean evax_bfd_relax_section
  109.   PARAMS ((bfd *abfd, asection *section, struct bfd_link_info *link_info,
  110.        boolean *again));
  111. static struct bfd_link_hash_table *evax_bfd_link_hash_table_create
  112.   PARAMS ((bfd *abfd));
  113. static boolean evax_bfd_link_add_symbols
  114.   PARAMS ((bfd *abfd, struct bfd_link_info *link_info));
  115. static boolean evax_bfd_final_link
  116.   PARAMS ((bfd *abfd, struct bfd_link_info *link_info));
  117. static boolean evax_bfd_link_split_section
  118.   PARAMS ((bfd *abfd, asection *section));
  119. static long evax_get_dynamic_symtab_upper_bound PARAMS ((bfd *abfd));
  120. static long evax_canonicalize_dynamic_symtab
  121.   PARAMS ((bfd *abfd, asymbol **symbols));
  122. static long evax_get_dynamic_reloc_upper_bound PARAMS ((bfd *abfd));
  123. static long evax_canonicalize_dynamic_reloc
  124.   PARAMS ((bfd *abfd, arelent **arel, asymbol **symbols));
  125. static boolean evax_bfd_merge_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd));
  126. static boolean evax_bfd_set_private_flags PARAMS ((bfd *abfd, flagword flags));
  127.  
  128. #define evax_make_empty_symbol _bfd_evax_make_empty_symbol
  129.  
  130. /*===========================================================================*/
  131.  
  132. const bfd_target evax_alpha_vec =
  133. {
  134.  
  135.   "evax-alpha",            /* name */
  136.   bfd_target_evax_flavour,
  137.   false,            /* data byte order is little */
  138.   false,            /* header byte order is little */
  139.  
  140.   (HAS_RELOC |            /* object flags */
  141.    HAS_LINENO | HAS_DEBUG |
  142.    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
  143.  
  144.   (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC), /* sect flags */
  145.   0,                /* symbol_leading_char */
  146.   ' ',                /* ar_pad_char */
  147.   15,                /* ar_max_namelen */
  148.   bfd_getl64,            /* bfd_getx64 */
  149.   bfd_getl_signed_64,        /* bfd_getx_signed_64 */
  150.   bfd_putl64,            /* bfd_putx64 */
  151.   bfd_getl32,            /* bfd_getx32 */
  152.   bfd_getl_signed_32,        /* bfd_getx_signed_32 */
  153.   bfd_putl32,            /* bfd_putx32 */
  154.   bfd_getl16,            /* bfd_getx16 */
  155.   bfd_getl_signed_16,        /* bfd_getx_signed_16 */
  156.   bfd_putl16,            /* bfd_putx16 */
  157.   bfd_getl64,            /* bfd_h_getx64 */
  158.   bfd_getl_signed_64,        /* bfd_h_getx_signed_64 */
  159.   bfd_putl64,            /* bfd_h_putx64 */
  160.   bfd_getl32,            /* bfd_h_getx32 */
  161.   bfd_getl_signed_32,        /* bfd_h_getx_signed_32 */
  162.   bfd_putl32,            /* bfd_h_putx32 */
  163.   bfd_getl16,            /* bfd_h_getx16 */
  164.   bfd_getl_signed_16,        /* bfd_h_getx_signed_16 */
  165.   bfd_putl16,            /* bfd_h_putx16 */
  166.  
  167.   {_bfd_dummy_target, evax_object_p,        /* bfd_check_format */
  168.    evax_archive_p, _bfd_dummy_target},
  169.   {bfd_false, evax_mkobject,            /* bfd_set_format */
  170.    _bfd_generic_mkarchive, bfd_false},
  171.   {bfd_false, evax_write_object_contents,    /* bfd_write_contents */
  172.    _bfd_write_archive_contents, bfd_false},
  173.  
  174.   BFD_JUMP_TABLE_GENERIC (evax),
  175.   BFD_JUMP_TABLE_COPY (evax),
  176.   BFD_JUMP_TABLE_CORE (evax),
  177.   BFD_JUMP_TABLE_ARCHIVE (evax),
  178.   BFD_JUMP_TABLE_SYMBOLS (evax),
  179.   BFD_JUMP_TABLE_RELOCS (evax),
  180.   BFD_JUMP_TABLE_WRITE (evax),
  181.   BFD_JUMP_TABLE_LINK (evax),
  182.   BFD_JUMP_TABLE_DYNAMIC (evax),
  183.  
  184.   (PTR) 0
  185. };
  186.  
  187.  
  188. /*===========================================================================*/
  189.  
  190. /* Initialize private data  */
  191.  
  192. static boolean
  193. evax_initialize (abfd)
  194.      bfd *abfd;
  195. {
  196.   int i;
  197.  
  198.   if (abfd->tdata.any != 0)
  199.     return true;
  200.  
  201.   bfd_set_start_address (abfd, (bfd_vma)-1);
  202.  
  203.   abfd->tdata.any = ((struct evax_private_data_struct*)
  204.              bfd_malloc (sizeof (struct evax_private_data_struct)));
  205.   if (abfd->tdata.any == 0)
  206.     return false;
  207.   PRIV(evax_buf) = 0;
  208.   PRIV(buf_size) = 0;
  209.   PRIV(rec_length) = 0;
  210.   PRIV(file_format) = FF_UNKNOWN;
  211.   PRIV(filename) = NULL;
  212.   PRIV(fixup_done) = false;
  213.   PRIV(sections) = NULL;
  214.  
  215.   PRIV(stack) = ((struct stack_struct *)
  216.          bfd_malloc (sizeof (struct stack_struct) * STACKSIZE));
  217.   if (PRIV(stack) == 0)
  218.     {
  219.      evax_init_no_mem1:
  220.       free (abfd->tdata.any);
  221.       abfd->tdata.any = 0;
  222.       return false;
  223.     }
  224.   PRIV(stackptr) = 0;
  225.  
  226.   PRIV(evax_symbol_table) = ((struct bfd_hash_table *)
  227.                  bfd_malloc (sizeof (struct bfd_hash_table)));
  228.   if (PRIV(evax_symbol_table) == 0)
  229.     {
  230.      evax_init_no_mem2:
  231.       free (PRIV(stack));
  232.       PRIV(stack) = 0;
  233.       goto evax_init_no_mem1;
  234.     }
  235.  
  236.   if (!bfd_hash_table_init (PRIV(evax_symbol_table), _bfd_evax_hash_newfunc))
  237.     return false;
  238.  
  239.   PRIV(location_stack) = ((struct location_struct *)
  240.               bfd_malloc (sizeof (struct location_struct)
  241.                       * LOCATION_SAVE_SIZE));
  242.   if (PRIV(location_stack) == 0)
  243.     {
  244.      evax_init_no_mem3:
  245.       free (PRIV(evax_symbol_table));
  246.       PRIV(evax_symbol_table) = 0;
  247.       goto evax_init_no_mem2;
  248.     }
  249.  
  250.   for (i=0; i<EVAX_SECTION_COUNT; i++)
  251.     {
  252.       PRIV(evax_section_table)[i] = NULL;
  253.       PRIV(evax_reloc_table)[i] = NULL;
  254.     }
  255.  
  256.   PRIV(output_buf) = (unsigned char *) malloc (MAX_OUTREC_SIZE);
  257.   if (PRIV(output_buf) == 0)
  258.     {
  259.       free (PRIV(location_stack));
  260.       PRIV(location_stack) = 0;
  261.       goto evax_init_no_mem3;
  262.     }
  263.   PRIV(push_level) = 0;
  264.   PRIV(pushed_size) = 0;
  265.   PRIV(length_pos) = 2;
  266.   PRIV(output_size) = 0;
  267.   PRIV(output_alignment) = 1;
  268.  
  269.   return true;
  270. }
  271.  
  272.  
  273. /* Fill symbol->section with section ptr
  274.    symbol->section is filled with the section index for defined symbols
  275.    during reading the EGSD section. But we need the pointer to the
  276.    bfd section later.
  277.  
  278.    It has the correct value for referenced (undefined section) symbols
  279.  
  280.    called from bfd_hash_traverse in evax_fixup_sections  */
  281.  
  282. static boolean
  283. fill_section_ptr (entry, sections)
  284.      struct bfd_hash_entry *entry;
  285.      PTR sections;
  286. {
  287.   asection *sec;
  288.   asymbol *sym;
  289.  
  290.   sym =  ((evax_symbol_entry *)entry)->symbol;
  291.   sec = sym->section;
  292.  
  293.   if (!bfd_is_und_section (sec))
  294.     {
  295.       sec = ((evax_symbol_entry *)entry)->symbol->section =
  296.     ((asection **)sections)[(int)sec];
  297.     }
  298.  
  299.   if (strcmp (sym->name, sec->name) == 0)
  300.     sym->flags |= BSF_SECTION_SYM;
  301.  
  302.   return true;
  303. }
  304.  
  305.  
  306. /* Fixup sections
  307.    set up all pointers and arrays, counters and sizes are fixed now
  308.  
  309.    we build a private sections vector for easy access since sections
  310.    are always referenced by an index number.
  311.  
  312.    alloc PRIV(sections) according to abfd->section_count
  313.     copy abfd->sections to PRIV(sections)  */
  314.  
  315. static boolean
  316. evax_fixup_sections (abfd)
  317.      bfd *abfd;
  318. {
  319.   asection *s;
  320.  
  321.   if (PRIV(fixup_done))
  322.     return true;
  323.  
  324.   PRIV(sections) = ((asection **)
  325.             bfd_malloc (abfd->section_count * sizeof (asection *)));
  326.   if (PRIV(sections) == 0)
  327.     return false;
  328.   PRIV(egsd_sec_count) = abfd->section_count;
  329.   s = abfd->sections;
  330.   while (s)
  331.     {
  332.       PRIV(sections)[s->index] = s;
  333.       s = s->next;
  334.     }
  335.  
  336.   /*
  337.    * traverse symbol table and fill in all section pointers
  338.    */
  339.  
  340.   bfd_hash_traverse (PRIV(evax_symbol_table), fill_section_ptr,
  341.             (PTR)(PRIV(sections)));
  342.  
  343.   PRIV(fixup_done) = true;
  344.  
  345.   return true;
  346. }
  347.  
  348. /*===========================================================================*/
  349.  
  350. /* Check the format for a file being read.
  351.    Return a (bfd_target *) if it's an object file or zero if not.  */
  352.  
  353. static const struct bfd_target *
  354. evax_object_p (abfd)
  355.      bfd *abfd;
  356. {
  357.   int err = 0;
  358.   int prev_type;
  359. #if EVAX_DEBUG
  360.   evax_debug (1, "evax_object_p(%p)\n", abfd);
  361. #endif
  362.   if (bfd_seek (abfd, 0L, SEEK_SET))
  363.     {
  364.       bfd_set_error (bfd_error_file_truncated);
  365.       return 0;
  366.     }
  367.  
  368.   prev_type = -1;
  369.  
  370.   do
  371.     {
  372. #if EVAX_DEBUG
  373.       evax_debug (3, "reading at %08lx\n", bfd_tell(abfd));
  374. #endif
  375.       if (_bfd_evax_next_record (abfd) < 0)
  376.     {
  377. #if EVAX_DEBUG
  378.       evax_debug (2, "next_record failed\n");      
  379. #endif
  380.       bfd_set_error (bfd_error_wrong_format);
  381.       return 0;
  382.     }
  383.  
  384.       if ((prev_type == EOBJ_S_C_EGSD) && (PRIV(rec_type) != EOBJ_S_C_EGSD))
  385.     {
  386.       if (evax_fixup_sections (abfd) == false)
  387.         {
  388. #if EVAX_DEBUG
  389.           evax_debug (2, "evax_fixup_sections failed\n");
  390. #endif
  391.           bfd_set_error (bfd_error_wrong_format);
  392.           return 0;
  393.         }
  394.     }
  395.  
  396.       prev_type = PRIV(rec_type);
  397.  
  398.       switch (PRIV(rec_type))
  399.     {
  400.       case EOBJ_S_C_EMH:
  401.         err = _bfd_evax_slurp_emh (abfd);
  402.         break;
  403.       case EOBJ_S_C_EEOM:
  404.         err = _bfd_evax_slurp_eeom (abfd);
  405.         break;
  406.       case EOBJ_S_C_EGSD:
  407.         err = _bfd_evax_slurp_egsd (abfd);
  408.         break;
  409.       case EOBJ_S_C_ETIR:
  410.         err = _bfd_evax_slurp_etir (abfd);
  411.         break;
  412.       case EOBJ_S_C_EDBG:
  413.         err = _bfd_evax_slurp_edbg (abfd);
  414.         break;
  415.       case EOBJ_S_C_ETBT:
  416.         err = _bfd_evax_slurp_etbt (abfd);
  417.         break;
  418.       default:
  419.         err = -1;
  420.     }
  421.       if (err != 0)
  422.     {
  423. #if EVAX_DEBUG
  424.       evax_debug (2, "slurp type %d failed with %d\n", PRIV(rec_type), err);
  425. #endif
  426.       bfd_set_error (bfd_error_wrong_format);
  427.       return 0;
  428.     }
  429.     }
  430.   while (prev_type != EOBJ_S_C_EEOM);
  431.  
  432.   /* set arch_info to alpha  */
  433.  
  434.   {
  435.     const bfd_arch_info_type *arch = bfd_scan_arch ("alpha");
  436.     if (arch == 0)
  437.       {
  438. #if EVAX_DEBUG
  439.     evax_debug (2, "arch not found\n");
  440. #endif
  441.     bfd_set_error (bfd_error_wrong_format);
  442.     return 0;
  443.       }
  444.     abfd->arch_info = arch;
  445.   }
  446.  
  447.   return &evax_alpha_vec;
  448. }
  449.  
  450.  
  451. /* Check the format for a file being read.
  452.    Return a (bfd_target *) if it's an archive file or zero.  */
  453.  
  454. static const struct bfd_target *
  455. evax_archive_p (abfd)
  456.      bfd *abfd;
  457. {
  458. #if EVAX_DEBUG
  459.   evax_debug (1, "evax_archive_p(%p)\n", abfd);
  460. #endif
  461.  
  462.   if (!evax_initialize (abfd))
  463.     return 0;
  464.  
  465.   return 0;
  466. }
  467.  
  468.  
  469. /* Set the format of a file being written.  */
  470.  
  471. static boolean
  472. evax_mkobject (abfd)
  473.      bfd *abfd;
  474. {
  475. #if EVAX_DEBUG
  476.   evax_debug (1, "evax_mkobject(%p)\n", abfd);
  477. #endif
  478.  
  479.   if (!evax_initialize (abfd))
  480.     return 0;
  481.  
  482.   {
  483.     const bfd_arch_info_type *arch = bfd_scan_arch ("alpha");
  484.     if (arch == 0)
  485.       {
  486.     bfd_set_error(bfd_error_wrong_format);
  487.     return 0;
  488.       }
  489.     abfd->arch_info = arch;
  490.   }
  491.  
  492.   return true;
  493. }
  494.  
  495.  
  496. /* Write cached information into a file being written, at bfd_close.  */
  497.  
  498. static boolean
  499. evax_write_object_contents (abfd)
  500.      bfd *abfd;
  501. {
  502. #if EVAX_DEBUG
  503.   evax_debug (1, "evax_write_object_contents(%p)\n", abfd);
  504. #endif
  505.  
  506.   if (abfd->section_count > 0)            /* we have sections */
  507.     {
  508.       if (_bfd_evax_write_emh (abfd) != 0)
  509.     return false;
  510.       if (_bfd_evax_write_egsd (abfd) != 0)
  511.     return false;
  512.       if (_bfd_evax_write_etir (abfd) != 0)
  513.     return false;
  514.       if (_bfd_evax_write_etbt (abfd) != 0)
  515.     return false;
  516.       if (_bfd_evax_write_eeom (abfd) != 0)
  517.     return false;
  518.     }
  519.   return true;
  520. }
  521.  
  522. /*-- 4.1, generic -----------------------------------------------------------*/
  523.  
  524. /* Called when the BFD is being closed to do any necessary cleanup.  */
  525.  
  526. static boolean
  527. evax_close_and_cleanup (abfd)
  528.      bfd *abfd;
  529. {
  530.   asection *sec;
  531.   evax_section *es, *es1;
  532.   evax_reloc *er, *er1;
  533.   int i;
  534.  
  535. #if EVAX_DEBUG
  536.   evax_debug (1, "evax_close_and_cleanup(%p)\n", abfd);
  537. #endif
  538.   if (abfd == 0)
  539.     return true;
  540.  
  541.   if (PRIV(evax_buf) != NULL)
  542.     {
  543.       free (PRIV(evax_buf));
  544.       PRIV(evax_buf) = NULL;
  545.     }
  546.   PRIV(buf_size) = 0;
  547.  
  548.   if (PRIV(filename) != NULL)
  549.     {
  550.       free (PRIV(filename));
  551.       PRIV(filename) = NULL;
  552.     }
  553.  
  554.   if (PRIV(output_buf) != 0)
  555.     {
  556.       free (PRIV(output_buf));
  557.       PRIV(output_buf) = 0;
  558.     }
  559.  
  560.   sec = abfd->sections;
  561.   while (sec != NULL)
  562.     {
  563.       if (sec->contents)
  564.     free (sec->contents);
  565.       sec = sec->next;
  566.     }
  567.  
  568.   if (PRIV(sections) != NULL)
  569.     {
  570.       free (PRIV(sections));
  571.       PRIV(sections) = NULL;
  572.     }
  573.  
  574.   if (PRIV(evax_symbol_table))
  575.     {
  576.       bfd_hash_table_free (PRIV(evax_symbol_table));
  577.       PRIV(evax_symbol_table) = 0;
  578.     }
  579.  
  580.   if (PRIV(stack))
  581.     {
  582.       free (PRIV(stack));
  583.       PRIV(stack) = 0;
  584.     }
  585.  
  586.   if (PRIV(location_stack))
  587.     {
  588.       free (PRIV(location_stack));
  589.       PRIV(location_stack) = 0;
  590.     }
  591.  
  592.   for (i = 0; i < EVAX_SECTION_COUNT; i++)
  593.     {
  594.       es = PRIV(evax_section_table)[i];
  595.       while (es != NULL)
  596.     {
  597.       es1 = es->next;
  598.       free (es);
  599.       es = es1;
  600.     }
  601.       PRIV(evax_section_table)[i] = NULL;
  602.  
  603.       er = PRIV(evax_reloc_table)[i];
  604.       while (er != NULL)
  605.     {
  606.       er1 = er->next;
  607.       free (er);
  608.       er = er1;
  609.     }
  610.       PRIV(evax_reloc_table)[i] = NULL;
  611.    }
  612.  
  613.   free (abfd->tdata.any);
  614.   abfd->tdata.any = NULL;
  615.  
  616.   return true;
  617. }
  618.  
  619.  
  620. /* Ask the BFD to free all cached information.  */
  621. static boolean
  622. evax_bfd_free_cached_info (abfd)
  623.      bfd *abfd;
  624. {
  625. #if EVAX_DEBUG
  626.   evax_debug (1, "evax_bfd_free_cached_info(%p)\n", abfd);
  627. #endif
  628.   return true;
  629. }
  630.  
  631.  
  632. /* Called when a new section is created.  */
  633.  
  634. static boolean
  635. evax_new_section_hook (abfd, section)
  636.      bfd *abfd;
  637.      asection *section;
  638. {
  639. #if EVAX_DEBUG
  640.   evax_debug (1, "evax_new_section_hook(%p, %s)\n", abfd, section->name);
  641. #endif
  642.   bfd_set_section_alignment(abfd, section, 4);
  643.   return true;
  644. }
  645.  
  646.  
  647. /* Read the contents of a section.
  648.    buf points to a buffer of buf_size bytes to be filled with
  649.    section data (starting at offset into section)  */
  650.  
  651. static boolean
  652. evax_get_section_contents (abfd, section, buf, offset, buf_size)
  653.      bfd *abfd;
  654.      asection *section;
  655.      PTR buf;
  656.      file_ptr offset;
  657.      bfd_size_type buf_size;
  658. {
  659. #if EVAX_DEBUG
  660.   evax_debug (1, "evax_get_section_contents(%p, %s, %p, off %ld, size %d)\n",
  661.          abfd, section->name, buf, offset, (int)buf_size);
  662. #endif
  663.  
  664.   /* shouldn't be called, since all sections are IN_MEMORY  */
  665.  
  666.   return false;
  667. }
  668.  
  669. /* Read the contents of a section.
  670.    buf points to a buffer of buf_size bytes to be filled with
  671.    section data (starting at offset into section)  */
  672.  
  673. static boolean
  674. evax_get_section_contents_in_window (abfd, section, w, offset, count)
  675.      bfd *abfd;
  676.      asection *section;
  677.      bfd_window *w;
  678.      file_ptr offset;
  679.      bfd_size_type count;
  680. {
  681. #if EVAX_DEBUG
  682.   evax_debug (1, "evax_get_section_contents_in_window(%p, %s, %p, off %ld, count %d)\n",
  683.          abfd, section->name, w, offset, (int)count);
  684. #endif
  685.  
  686.   /* shouldn't be called, since all sections are IN_MEMORY  */
  687.  
  688.   return false;
  689. }
  690.  
  691. /*-- Part 4.2, copy private data --------------------------------------------*/
  692.  
  693. /* Called to copy BFD general private data from one object file
  694.    to another.  */
  695.  
  696. static boolean
  697. evax_bfd_copy_private_bfd_data (src, dest)
  698.      bfd *src;
  699.      bfd *dest;
  700. {
  701. #if EVAX_DEBUG
  702.   evax_debug (1, "evax_bfd_copy_private_bfd_data(%p, %p)\n", src, dest);
  703. #endif
  704.   return true;
  705. }
  706.  
  707.  
  708. /* Merge private BFD information from the BFD @var{ibfd} to the
  709.    the output file BFD @var{obfd} when linking.  Return <<true>>
  710.    on success, <<false>> on error.  Possible error returns are:
  711.  
  712.    o <<bfd_error_no_memory>> -
  713.      Not enough memory exists to create private data for @var{obfd}.  */
  714.  
  715. static boolean
  716. evax_bfd_merge_private_bfd_data (ibfd, obfd)
  717.      bfd *ibfd;
  718.      bfd *obfd;
  719. {
  720. #if EVAX_DEBUG
  721.   evax_debug (1,"evax_bfd_merge_private_bfd_data(%p, %p)\n", ibfd, obfd);
  722. #endif
  723.   return true;
  724. }
  725.  
  726.  
  727. /* Set private BFD flag information in the BFD @var{abfd}.
  728.    Return <<true>> on success, <<false>> on error.  Possible error
  729.    returns are:
  730.  
  731.    o <<bfd_error_no_memory>> -
  732.      Not enough memory exists to create private data for @var{obfd}.  */
  733.  
  734. static boolean
  735. evax_bfd_set_private_flags (abfd, flags)
  736.      bfd *abfd;
  737.      flagword flags;
  738. {
  739. #if EVAX_DEBUG
  740.   evax_debug (1,"evax_bfd_set_private_flags(%p, %lx)\n", abfd, (long)flags);
  741. #endif
  742.   return true;
  743. }
  744.  
  745.  
  746. /* Called to copy BFD private section data from one object file
  747.    to another.  */
  748.  
  749. static boolean
  750. evax_bfd_copy_private_section_data (srcbfd, srcsec, dstbfd, dstsec)
  751.      bfd *srcbfd;
  752.      asection *srcsec;
  753.      bfd *dstbfd;
  754.      asection *dstsec;
  755. {
  756. #if EVAX_DEBUG
  757.   evax_debug (1, "evax_bfd_copy_private_section_data(%p, %s, %p, %s)\n",
  758.          srcbfd, srcsec->name, dstbfd, dstsec->name);
  759. #endif
  760.   return true;
  761. }
  762.  
  763. /* Called to copy BFD private symbol data from one object file
  764.    to another.  */
  765.  
  766. static boolean 
  767. evax_bfd_copy_private_symbol_data (ibfd, isym, obfd, osym)
  768.      bfd *ibfd;
  769.      asymbol *isym;
  770.      bfd *obfd;
  771.      asymbol *osym;
  772. {
  773. #if EVAX_DEBUG
  774.   evax_debug (1, "evax_bfd_copy_private_symbol_data(%p, %s, %p, %s)\n",
  775.          ibfd, isym->name, obfd, osym->name);
  776. #endif
  777.   return true;
  778. }
  779.  
  780. /*-- Part 4.3, core file ----------------------------------------------------*/
  781.  
  782. /* Return a read-only string explaining which program was running
  783.    when it failed and produced the core file abfd.  */
  784.  
  785. static char *
  786. evax_core_file_failing_command (abfd)
  787.      bfd *abfd;
  788. {
  789. #if EVAX_DEBUG
  790.   evax_debug (1, "evax_core_file_failing_command(%p)\n", abfd);
  791. #endif
  792.   return 0;
  793. }
  794.  
  795.  
  796. /* Returns the signal number which caused the core dump which
  797.    generated the file the BFD abfd is attached to.  */
  798.  
  799. static int
  800. evax_core_file_failing_signal (abfd)
  801.      bfd *abfd;
  802. {
  803. #if EVAX_DEBUG
  804.   evax_debug (1, "evax_core_file_failing_signal(%p)\n", abfd);
  805. #endif
  806.   return 0;
  807. }
  808.  
  809.  
  810. /* Return true if the core file attached to core_bfd was generated
  811.    by a run of the executable file attached to exec_bfd, false otherwise.  */
  812.  
  813. static boolean
  814. evax_core_file_matches_executable_p (abfd, bbfd)
  815.      bfd *abfd;
  816.      bfd *bbfd;
  817. {
  818. #if EVAX_DEBUG
  819.   evax_debug (1, "evax_core_file_matches_executable_p(%p, %p)\n", abfd, bbfd);
  820. #endif
  821.   return false;
  822. }
  823.  
  824. /*-- Part 4.4, archive ------------------------------------------------------*/
  825.  
  826. /* ???    do something with an archive map.
  827.    Return false on error, true otherwise.  */
  828.  
  829. static boolean
  830. evax_slurp_armap (abfd)
  831.      bfd *abfd;
  832. {
  833. #if EVAX_DEBUG
  834.   evax_debug (1, "evax_slurp_armap(%p)\n", abfd);
  835. #endif
  836.   return false;
  837. }
  838.  
  839.  
  840. /* ???    do something with an extended name table.
  841.    Return false on error, true otherwise.  */
  842.  
  843. static boolean
  844. evax_slurp_extended_name_table (abfd)
  845.      bfd *abfd;
  846. {
  847. #if EVAX_DEBUG
  848.   evax_debug (1, "evax_slurp_extended_name_table(%p)\n", abfd);
  849. #endif
  850.   return false;
  851. }
  852.  
  853.  
  854. /* ???    do something with an extended name table.
  855.    Return false on error, true otherwise.  */
  856.  
  857. static boolean
  858. evax_construct_extended_name_table (abfd, tabloc, tablen, name)
  859.      bfd *abfd;
  860.      char **tabloc;
  861.      bfd_size_type *tablen;
  862.      const char **name;
  863. {
  864. #if EVAX_DEBUG
  865.   evax_debug (1, "evax_construct_extended_name_table(%p)\n", abfd);
  866. #endif
  867.   return false;
  868. }
  869.  
  870.  
  871. /* Truncate the name of an archive to match system-dependent restrictions  */
  872.  
  873. static void
  874. evax_truncate_arname (abfd, pathname, arhdr)
  875.      bfd *abfd;
  876.      CONST char *pathname;
  877.      char *arhdr;
  878. {
  879. #if EVAX_DEBUG
  880.   evax_debug (1, "evax_truncate_arname(%p, %s, %s)\n", abfd, pathname, arhdr);
  881. #endif
  882.   return;
  883. }
  884.  
  885.  
  886. /* ???    write archive map  */
  887.  
  888. static boolean
  889. evax_write_armap (arch, elength, map, orl_count, stridx)
  890.      bfd *arch;
  891.      unsigned int elength;
  892.      struct orl *map;
  893.      unsigned int orl_count;
  894.      int stridx;
  895. {
  896. #if EVAX_DEBUG
  897.   evax_debug (1, "evax_write_armap(%p, %d, %p, %d %d)\n",
  898.     arch, elength, map, orl_count, stridx);
  899. #endif
  900.   return true;
  901. }
  902.  
  903. /* Read archive header ???  */
  904.  
  905. static PTR
  906. evax_read_ar_hdr (abfd)
  907.     bfd * abfd;
  908. {
  909. #if EVAX_DEBUG
  910.   evax_debug (1, "evax_read_ar_hdr(%p)\n", abfd);
  911. #endif
  912.   return (PTR)0;
  913. }
  914.  
  915.  
  916. /* Provided a BFD, @var{archive}, containing an archive and NULL, open
  917.    an input BFD on the first contained element and returns that.
  918.    Subsequent calls should pass the archive and the previous return value
  919.    to return a created BFD to the next contained element.
  920.    NULL is returned when there are no more.  */
  921.  
  922. static bfd *
  923. evax_openr_next_archived_file (arch, prev)
  924.      bfd *arch;
  925.      bfd *prev;
  926. {
  927. #if EVAX_DEBUG
  928.   evax_debug (1, "evax_openr_next_archived_file(%p, %p)\n", arch, prev);
  929. #endif
  930.   return false;
  931. }
  932.  
  933.  
  934. /* Return the BFD which is referenced by the symbol in ABFD indexed by
  935.    INDEX.  INDEX should have been returned by bfd_get_next_mapent.  */
  936.  
  937. static bfd *
  938. evax_get_elt_at_index (abfd, index)
  939.      bfd *abfd;
  940.      symindex index;
  941. {
  942. #if EVAX_DEBUG
  943.   evax_debug (1, "evax_get_elt_at_index(%p, %p)\n", abfd, index);
  944. #endif
  945.   return _bfd_generic_get_elt_at_index(abfd, index);
  946. }
  947.  
  948.  
  949. /* ???
  950.    -> bfd_generic_stat_arch_elt  */
  951.  
  952. static int
  953. evax_generic_stat_arch_elt (abfd, stat)
  954.      bfd *abfd;
  955.      struct stat *stat;
  956. {
  957. #if EVAX_DEBUG
  958.   evax_debug (1, "evax_generic_stat_arch_elt(%p, %p)\n", abfd, stat);
  959. #endif
  960.   return bfd_generic_stat_arch_elt(abfd, stat);
  961. }
  962.  
  963.  
  964. /* This is a new function in bfd 2.5  */
  965.  
  966. static boolean
  967. evax_update_armap_timestamp (abfd)
  968.      bfd *abfd;
  969. {
  970. #if EVAX_DEBUG
  971.   evax_debug (1, "evax_update_armap_timestamp(%p)\n", abfd);
  972. #endif
  973.   return true;
  974. }
  975.  
  976. /*-- Part 4.5, symbols --------------------------------------------------------*/
  977.  
  978. /* Return the number of bytes required to store a vector of pointers
  979.    to asymbols for all the symbols in the BFD abfd, including a
  980.    terminal NULL pointer. If there are no symbols in the BFD,
  981.    then return 0.  If an error occurs, return -1.  */
  982.  
  983. static long
  984. evax_get_symtab_upper_bound (abfd)
  985.      bfd *abfd;
  986. {
  987. #if EVAX_DEBUG
  988.   evax_debug (1, "evax_get_symtab_upper_bound(%p), %d symbols\n", abfd, PRIV(egsd_sym_count));
  989. #endif
  990.   return (PRIV(egsd_sym_count)+1) * sizeof(asymbol *);
  991. }
  992.  
  993.  
  994. /* Copy symbols from hash table to symbol vector
  995.  
  996.    called from bfd_hash_traverse in evax_get_symtab
  997.    init counter to 0 if entry == 0  */
  998.  
  999. static boolean
  1000. copy_symbols (entry, arg)
  1001.      struct bfd_hash_entry *entry;
  1002.      PTR arg;
  1003. {
  1004.   bfd *abfd = (bfd *) arg;
  1005.  
  1006.   if (entry == NULL)    /* init counter */
  1007.     PRIV(symnum) = 0;
  1008.   else            /* fill vector, inc counter */
  1009.     PRIV(symcache)[PRIV(symnum)++] = ((evax_symbol_entry *)entry)->symbol;
  1010.  
  1011.   return true;
  1012. }
  1013.  
  1014.  
  1015. /* Read the symbols from the BFD abfd, and fills in the vector
  1016.    location with pointers to the symbols and a trailing NULL.
  1017.  
  1018.    return # of symbols read  */
  1019.  
  1020. static long
  1021. evax_get_symtab (abfd, symbols)
  1022.      bfd *abfd;
  1023.      asymbol **symbols;
  1024. {
  1025. #if EVAX_DEBUG
  1026.   evax_debug (1, "evax_get_symtab(%p, <ret>)\n", abfd);
  1027. #endif
  1028.  
  1029.     /* init counter */
  1030.   (void)copy_symbols((struct bfd_hash_entry *)0, abfd);
  1031.  
  1032.     /* traverse table and fill symbols vector */
  1033.  
  1034.   PRIV(symcache) = symbols;
  1035.   bfd_hash_traverse(PRIV(evax_symbol_table), copy_symbols, (PTR)abfd);
  1036.  
  1037.   symbols[bfd_get_symcount(abfd)] = NULL;
  1038.  
  1039.   return bfd_get_symcount(abfd);
  1040. }
  1041.  
  1042.  
  1043. /* Create a new asymbol structure for the BFD abfd and return a pointer
  1044.    to it.
  1045.    This routine is necessary because each back end has private information
  1046.    surrounding the asymbol. Building your own asymbol and pointing to it
  1047.    will not create the private information, and will cause problems later on.  */
  1048.  
  1049. asymbol *
  1050. _bfd_evax_make_empty_symbol (abfd)
  1051.      bfd *abfd;
  1052. {
  1053.   asymbol *symbol = (asymbol *)bfd_zalloc(abfd, sizeof(asymbol));
  1054.  
  1055. #if EVAX_DEBUG
  1056.   evax_debug (1, "_bfd_evax_make_empty_symbol(%p)\n", abfd);
  1057. #endif
  1058.  
  1059.   if (symbol == 0)
  1060.     {
  1061.       bfd_set_error (bfd_error_no_memory);
  1062.       return 0;
  1063.     }
  1064.   symbol->the_bfd = abfd;
  1065.  
  1066.   return symbol;
  1067. }
  1068.  
  1069.  
  1070. /* Print symbol to file according to how. how is one of
  1071.    bfd_print_symbol_name    just print the name
  1072.    bfd_print_symbol_more    print more (???)
  1073.    bfd_print_symbol_all    print all we know, which is not much right now :-)  */
  1074.  
  1075. static void
  1076. evax_print_symbol (abfd, file, symbol, how)
  1077.      bfd *abfd;
  1078.      PTR file;
  1079.      asymbol *symbol;
  1080.      bfd_print_symbol_type how;
  1081. {
  1082. #if EVAX_DEBUG
  1083.   evax_debug (1, "evax_print_symbol(%p, %p, %p, %d)\n", abfd, file, symbol, how);
  1084. #endif
  1085.  
  1086.   switch (how)
  1087.     {
  1088.       case bfd_print_symbol_name:
  1089.       case bfd_print_symbol_more:
  1090.     fprintf((FILE *)file," %s", symbol->name);
  1091.       break;
  1092.  
  1093.       break;
  1094.  
  1095.       case bfd_print_symbol_all:
  1096.     {
  1097.       CONST char *section_name = symbol->section->name;
  1098.  
  1099.       bfd_print_symbol_vandf((PTR)file,symbol);
  1100.  
  1101.       fprintf((FILE *)file," %-8s %s", section_name, symbol->name);
  1102.         }
  1103.       break;
  1104.     }
  1105.   return;
  1106. }
  1107.  
  1108.  
  1109. /* Return information about symbol in ret.
  1110.  
  1111.    fill type, value and name
  1112.    type:
  1113.     A    absolute
  1114.     B    bss segment symbol
  1115.     C    common symbol
  1116.     D    data segment symbol
  1117.     f    filename
  1118.     t    a static function symbol
  1119.     T    text segment symbol
  1120.     U    undefined
  1121.     -    debug  */
  1122.  
  1123. static void
  1124. evax_get_symbol_info (abfd, symbol, ret)
  1125.      bfd *abfd;
  1126.      asymbol *symbol;
  1127.      symbol_info *ret;
  1128. {
  1129.   asection *sec;
  1130.  
  1131. #if EVAX_DEBUG
  1132.   evax_debug (1, "evax_get_symbol_info(%p, %p, <ret>)\n", abfd, symbol);
  1133. #endif
  1134.  
  1135.   sec = symbol->section;
  1136.  
  1137.   if (bfd_is_com_section (sec))
  1138.     ret->type = 'C';
  1139.   else if (bfd_is_abs_section (sec))
  1140.     ret->type = 'A';
  1141.   else if (bfd_is_und_section (sec))
  1142.     ret->type = 'U';
  1143.   else if (bfd_is_abs_section (sec))
  1144.     ret->type = 'A';
  1145.   else if (bfd_is_ind_section (sec))
  1146.     ret->type = 'I';
  1147.   else if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
  1148.     ret->type = 'T';
  1149.   else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
  1150.     ret->type = 'D';
  1151.   else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
  1152.     ret->type = 'B';
  1153.   else
  1154.     ret->type = '-';
  1155.  
  1156.   if (ret->type != 'U')
  1157.     ret->value = symbol->value + symbol->section->vma;
  1158.   else
  1159.     ret->value = 0;
  1160.   ret->name = symbol->name;
  1161.  
  1162.   return;
  1163. }
  1164.  
  1165.  
  1166. /* Return true if the given symbol sym in the BFD abfd is
  1167.    a compiler generated local label, else return false.  */
  1168.  
  1169. static boolean
  1170. evax_bfd_is_local_label (abfd, symbol)
  1171.      bfd *abfd;
  1172.      asymbol *symbol;
  1173. {
  1174. #if EVAX_DEBUG
  1175.   evax_debug (1, "evax_bfd_is_local_label(%p, %p)\n", abfd, symbol);
  1176. #endif
  1177.   return false;
  1178. }
  1179.  
  1180.  
  1181. /* Get source line number for symbol  */
  1182.  
  1183. static alent *
  1184. evax_get_lineno (abfd, symbol)
  1185.      bfd *abfd;
  1186.      asymbol *symbol;
  1187. {
  1188. #if EVAX_DEBUG
  1189.   evax_debug (1, "evax_get_lineno(%p, %p)\n", abfd, symbol);
  1190. #endif
  1191.   return 0;
  1192. }
  1193.  
  1194.  
  1195. /* Provided a BFD, a section and an offset into the section, calculate and
  1196.    return the name of the source file and the line nearest to the wanted
  1197.    location.  */
  1198.  
  1199. static boolean
  1200. evax_find_nearest_line (abfd, section, symbols, offset, file, func, line)
  1201.      bfd *abfd;
  1202.      asection *section;
  1203.      asymbol **symbols;
  1204.      bfd_vma offset;
  1205.      CONST char **file;
  1206.      CONST char **func;
  1207.      unsigned int *line;
  1208. {
  1209. #if EVAX_DEBUG
  1210.   evax_debug (1, "evax_find_nearest_line(%p, %s, %p, %ld, <ret>, <ret>, <ret>)\n",
  1211.           abfd, section->name, symbols, (long int)offset);
  1212. #endif
  1213.   return false;
  1214. }
  1215.  
  1216.  
  1217. /* Back-door to allow format-aware applications to create debug symbols
  1218.    while using BFD for everything else.  Currently used by the assembler
  1219.    when creating COFF files.  */
  1220.  
  1221. static asymbol *
  1222. evax_bfd_make_debug_symbol (abfd, ptr, size)
  1223.      bfd *abfd;
  1224.      void *ptr;
  1225.      unsigned long size;
  1226. {
  1227. #if EVAX_DEBUG
  1228.   evax_debug (1, "evax_bfd_make_debug_symbol(%p, %p, %ld)\n", abfd, ptr, size);
  1229. #endif
  1230.   return 0;
  1231. }
  1232.  
  1233.  
  1234. /* Read minisymbols.  For minisymbols, we use the unmodified a.out
  1235.    symbols.  The minisymbol_to_symbol function translates these into
  1236.    BFD asymbol structures.  */
  1237.  
  1238. static long
  1239. evax_read_minisymbols (abfd, dynamic, minisymsp, sizep)
  1240.      bfd *abfd;
  1241.      boolean dynamic;
  1242.      PTR *minisymsp;
  1243.      unsigned int *sizep;
  1244. {
  1245. #if EVAX_DEBUG
  1246.   evax_debug (1, "evax_read_minisymbols(%p, %d, %p, %d)\n", abfd, dynamic, minisymsp, *sizep);
  1247. #endif
  1248.   return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
  1249. }
  1250.  
  1251. /* Convert a minisymbol to a BFD asymbol.  A minisymbol is just an
  1252.    unmodified a.out symbol.  The SYM argument is a structure returned
  1253.    by bfd_make_empty_symbol, which we fill in here.  */
  1254.  
  1255. static asymbol *
  1256. evax_minisymbol_to_symbol (abfd, dynamic, minisym, sym)
  1257.      bfd *abfd;
  1258.      boolean dynamic;
  1259.      const PTR minisym;
  1260.      asymbol *sym;
  1261. {
  1262. #if EVAX_DEBUG
  1263.   evax_debug (1, "evax_minisymbol_to_symbol(%p, %d, %p, %p)\n", abfd, dynamic, minisym, sym);
  1264. #endif
  1265.   return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
  1266. }
  1267.  
  1268. /*-- Part 4.6, relocations --------------------------------------------------*/
  1269.  
  1270. /* Return the number of bytes required to store the relocation information
  1271.    associated with section sect attached to bfd abfd.
  1272.    If an error occurs, return -1.  */
  1273.  
  1274. static long
  1275. evax_get_reloc_upper_bound (abfd, section)
  1276.      bfd *abfd;
  1277.      asection *section;
  1278. {
  1279. #if EVAX_DEBUG
  1280.   evax_debug (1, "evax_get_reloc_upper_bound(%p, %s)\n", abfd, section->name);
  1281. #endif
  1282.   return -1L;
  1283. }
  1284.  
  1285.  
  1286. /* Call the back end associated with the open BFD abfd and translate the
  1287.    external form of the relocation information attached to sec into the
  1288.    internal canonical form.  Place the table into memory at loc, which has
  1289.    been preallocated, usually by a call to bfd_get_reloc_upper_bound.
  1290.    Returns the number of relocs, or -1 on error.  */
  1291.  
  1292. static long
  1293. evax_canonicalize_reloc (abfd, section, location, symbols)
  1294.      bfd *abfd;
  1295.      asection *section;
  1296.      arelent **location;
  1297.      asymbol **symbols;
  1298. {
  1299. #if EVAX_DEBUG
  1300.   evax_debug (1, "evax_canonicalize_reloc(%p, %s, <ret>, <ret>)\n", abfd, section->name);
  1301. #endif
  1302.   return false;
  1303. }
  1304.  
  1305. /*---------------------------------------------------------------------------*/
  1306. /* this is just copied from ecoff-alpha, needs to be fixed probably */
  1307.  
  1308. /* How to process the various reloc types.  */
  1309.  
  1310. static bfd_reloc_status_type
  1311. reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message)
  1312.      bfd *abfd;
  1313.      arelent *reloc;
  1314.      asymbol *sym;
  1315.      PTR data;
  1316.      asection *sec;
  1317.      bfd *output_bfd;
  1318.      char **error_message;
  1319. {
  1320.   evax_reloc *er;
  1321.  
  1322. #if EVAX_DEBUG
  1323.   evax_debug (1, "reloc_nil(abfd %p, output_bfd %p)\n", abfd, output_bfd);
  1324.   evax_debug (2, "In section %s, symbol %s\n",
  1325.     sec->name, sym->name);
  1326.   evax_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
  1327.         reloc->sym_ptr_ptr[0]->name,
  1328.         (unsigned long)reloc->address,
  1329.         (unsigned long)reloc->addend, reloc->howto->name);
  1330.   evax_debug (2, "data at %p\n", data);
  1331. /*  _bfd_hexdump (2, data, bfd_get_reloc_size(reloc->howto),0); */
  1332. #endif
  1333.  
  1334.   er = (evax_reloc *)malloc (sizeof(evax_reloc));
  1335.   if (er == NULL)
  1336.     {
  1337.       bfd_set_error (bfd_error_no_memory);
  1338.       return bfd_reloc_notsupported;    /* FIXME */
  1339.     }
  1340.   er->section = sec;
  1341.   er->reloc = reloc;
  1342.   er->next = NULL;
  1343.   if (PRIV(evax_reloc_table)[sec->index] == NULL)
  1344.     {
  1345.       PRIV(evax_reloc_table)[sec->index] = er;
  1346.     }
  1347.   else
  1348.     {
  1349.       er->next = PRIV(evax_reloc_table)[sec->index];
  1350.     }
  1351.   return bfd_reloc_ok;
  1352. }
  1353.  
  1354. /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
  1355.    from smaller values.  Start with zero, widen, *then* decrement.  */
  1356. #define MINUS_ONE    (((bfd_vma)0) - 1)
  1357.  
  1358. static reloc_howto_type alpha_howto_table[] =
  1359. {
  1360.   HOWTO (ALPHA_R_IGNORE,    /* type */
  1361.      0,            /* rightshift */
  1362.      0,            /* size (0 = byte, 1 = short, 2 = long) */
  1363.      8,            /* bitsize */
  1364.      true,            /* pc_relative */
  1365.      0,            /* bitpos */
  1366.      complain_overflow_dont, /* complain_on_overflow */
  1367.      reloc_nil,        /* special_function */
  1368.      "IGNORE",        /* name */
  1369.      true,            /* partial_inplace */
  1370.      0,            /* src_mask */
  1371.      0,            /* dst_mask */
  1372.      true),            /* pcrel_offset */
  1373.  
  1374.   /* A 64 bit reference to a symbol.  */
  1375.   HOWTO (ALPHA_R_REFQUAD,    /* type */
  1376.      0,            /* rightshift */
  1377.      4,            /* size (0 = byte, 1 = short, 2 = long) */
  1378.      64,            /* bitsize */
  1379.      false,            /* pc_relative */
  1380.      0,            /* bitpos */
  1381.      complain_overflow_bitfield, /* complain_on_overflow */
  1382.      reloc_nil,        /* special_function */
  1383.      "REFQUAD",        /* name */
  1384.      true,            /* partial_inplace */
  1385.      MINUS_ONE,        /* src_mask */
  1386.      MINUS_ONE,        /* dst_mask */
  1387.      false),        /* pcrel_offset */
  1388.  
  1389.   /* A 21 bit branch.  The native assembler generates these for
  1390.      branches within the text segment, and also fills in the PC
  1391.      relative offset in the instruction.  */
  1392.   HOWTO (ALPHA_R_BRADDR,    /* type */
  1393.      2,            /* rightshift */
  1394.      2,            /* size (0 = byte, 1 = short, 2 = long) */
  1395.      21,            /* bitsize */
  1396.      true,            /* pc_relative */
  1397.      0,            /* bitpos */
  1398.      complain_overflow_signed, /* complain_on_overflow */
  1399.      reloc_nil,        /* special_function */
  1400.      "BRADDR",        /* name */
  1401.      true,            /* partial_inplace */
  1402.      0x1fffff,        /* src_mask */
  1403.      0x1fffff,        /* dst_mask */
  1404.      false),        /* pcrel_offset */
  1405.  
  1406.   /* A hint for a jump to a register.  */
  1407.   HOWTO (ALPHA_R_HINT,        /* type */
  1408.      2,            /* rightshift */
  1409.      1,            /* size (0 = byte, 1 = short, 2 = long) */
  1410.      14,            /* bitsize */
  1411.      true,            /* pc_relative */
  1412.      0,            /* bitpos */
  1413.      complain_overflow_dont, /* complain_on_overflow */
  1414.      reloc_nil,        /* special_function */
  1415.      "HINT",        /* name */
  1416.      true,            /* partial_inplace */
  1417.      0x3fff,        /* src_mask */
  1418.      0x3fff,        /* dst_mask */
  1419.      false),        /* pcrel_offset */
  1420.  
  1421.   /* 16 bit PC relative offset.  */
  1422.   HOWTO (ALPHA_R_SREL16,    /* type */
  1423.      0,            /* rightshift */
  1424.      1,            /* size (0 = byte, 1 = short, 2 = long) */
  1425.      16,            /* bitsize */
  1426.      true,            /* pc_relative */
  1427.      0,            /* bitpos */
  1428.      complain_overflow_signed, /* complain_on_overflow */
  1429.      reloc_nil,        /* special_function */
  1430.      "SREL16",        /* name */
  1431.      true,            /* partial_inplace */
  1432.      0xffff,        /* src_mask */
  1433.      0xffff,        /* dst_mask */
  1434.      false),        /* pcrel_offset */
  1435.  
  1436.   /* 32 bit PC relative offset.  */
  1437.   HOWTO (ALPHA_R_SREL32,    /* type */
  1438.      0,            /* rightshift */
  1439.      2,            /* size (0 = byte, 1 = short, 2 = long) */
  1440.      32,            /* bitsize */
  1441.      true,            /* pc_relative */
  1442.      0,            /* bitpos */
  1443.      complain_overflow_signed, /* complain_on_overflow */
  1444.      reloc_nil,        /* special_function */
  1445.      "SREL32",        /* name */
  1446.      true,            /* partial_inplace */
  1447.      0xffffffff,        /* src_mask */
  1448.      0xffffffff,        /* dst_mask */
  1449.      false),        /* pcrel_offset */
  1450.  
  1451.   /* A 64 bit PC relative offset.  */
  1452.   HOWTO (ALPHA_R_SREL64,    /* type */
  1453.      0,            /* rightshift */
  1454.      4,            /* size (0 = byte, 1 = short, 2 = long) */
  1455.      64,            /* bitsize */
  1456.      true,            /* pc_relative */
  1457.      0,            /* bitpos */
  1458.      complain_overflow_signed, /* complain_on_overflow */
  1459.      reloc_nil,        /* special_function */
  1460.      "SREL64",        /* name */
  1461.      true,            /* partial_inplace */
  1462.      MINUS_ONE,        /* src_mask */
  1463.      MINUS_ONE,        /* dst_mask */
  1464.      false),        /* pcrel_offset */
  1465.  
  1466.   /* Push a value on the reloc evaluation stack.  */
  1467.   HOWTO (ALPHA_R_OP_PUSH,    /* type */
  1468.      0,            /* rightshift */
  1469.      0,            /* size (0 = byte, 1 = short, 2 = long) */
  1470.      0,            /* bitsize */
  1471.      false,            /* pc_relative */
  1472.      0,            /* bitpos */
  1473.      complain_overflow_dont, /* complain_on_overflow */
  1474.      reloc_nil,        /* special_function */
  1475.      "OP_PUSH",        /* name */
  1476.      false,            /* partial_inplace */
  1477.      0,            /* src_mask */
  1478.      0,            /* dst_mask */
  1479.      false),        /* pcrel_offset */
  1480.  
  1481.   /* Store the value from the stack at the given address.  Store it in
  1482.      a bitfield of size r_size starting at bit position r_offset.  */
  1483.   HOWTO (ALPHA_R_OP_STORE,    /* type */
  1484.      0,            /* rightshift */
  1485.      4,            /* size (0 = byte, 1 = short, 2 = long) */
  1486.      64,            /* bitsize */
  1487.      false,            /* pc_relative */
  1488.      0,            /* bitpos */
  1489.      complain_overflow_dont, /* complain_on_overflow */
  1490.      reloc_nil,        /* special_function */
  1491.      "OP_STORE",        /* name */
  1492.      false,            /* partial_inplace */
  1493.      0,            /* src_mask */
  1494.      MINUS_ONE,        /* dst_mask */
  1495.      false),        /* pcrel_offset */
  1496.  
  1497.   /* Subtract the reloc address from the value on the top of the
  1498.      relocation stack.  */
  1499.   HOWTO (ALPHA_R_OP_PSUB,    /* type */
  1500.      0,            /* rightshift */
  1501.      0,            /* size (0 = byte, 1 = short, 2 = long) */
  1502.      0,            /* bitsize */
  1503.      false,            /* pc_relative */
  1504.      0,            /* bitpos */
  1505.      complain_overflow_dont, /* complain_on_overflow */
  1506.      reloc_nil,        /* special_function */
  1507.      "OP_PSUB",        /* name */
  1508.      false,            /* partial_inplace */
  1509.      0,            /* src_mask */
  1510.      0,            /* dst_mask */
  1511.      false),        /* pcrel_offset */
  1512.  
  1513.   /* Shift the value on the top of the relocation stack right by the
  1514.      given value.  */
  1515.   HOWTO (ALPHA_R_OP_PRSHIFT,    /* type */
  1516.      0,            /* rightshift */
  1517.      0,            /* size (0 = byte, 1 = short, 2 = long) */
  1518.      0,            /* bitsize */
  1519.      false,            /* pc_relative */
  1520.      0,            /* bitpos */
  1521.      complain_overflow_dont, /* complain_on_overflow */
  1522.      reloc_nil,        /* special_function */
  1523.      "OP_PRSHIFT",        /* name */
  1524.      false,            /* partial_inplace */
  1525.      0,            /* src_mask */
  1526.      0,            /* dst_mask */
  1527.      false),        /* pcrel_offset */
  1528.  
  1529.   /* Hack. Linkage is done by linker.  */
  1530.   HOWTO (ALPHA_R_LINKAGE,    /* type */
  1531.      0,            /* rightshift */
  1532.      8,            /* size (0 = byte, 1 = short, 2 = long) */
  1533.      256,            /* bitsize */
  1534.      false,            /* pc_relative */
  1535.      0,            /* bitpos */
  1536.      complain_overflow_dont, /* complain_on_overflow */
  1537.      reloc_nil,        /* special_function */
  1538.      "LINKAGE",        /* name */
  1539.      false,            /* partial_inplace */
  1540.      0,            /* src_mask */
  1541.      0,            /* dst_mask */
  1542.      false),        /* pcrel_offset */
  1543.  
  1544.   /* Switch table, 32bit relocation.  */
  1545.   HOWTO (ALPHA_R_SWREL32,    /* type */
  1546.      0,            /* rightshift */
  1547.      2,            /* size (0 = byte, 1 = short, 2 = long) */
  1548.      32,            /* bitsize */
  1549.      false,            /* pc_relative */
  1550.      0,            /* bitpos */
  1551.      complain_overflow_dont, /* complain_on_overflow */
  1552.      reloc_nil,        /* special_function */
  1553.      "SWREL32",        /* name */
  1554.      false,            /* partial_inplace */
  1555.      0xffffffff,        /* src_mask */
  1556.      0xffffffff,        /* dst_mask */
  1557.      false),        /* pcrel_offset */
  1558.  
  1559.   /* Switch table, 64bit relocation.  */
  1560.   HOWTO (ALPHA_R_SWREL64,    /* type */
  1561.      0,            /* rightshift */
  1562.      4,            /* size (0 = byte, 1 = short, 2 = long) */
  1563.      64,            /* bitsize */
  1564.      false,            /* pc_relative */
  1565.      0,            /* bitpos */
  1566.      complain_overflow_dont, /* complain_on_overflow */
  1567.      reloc_nil,        /* special_function */
  1568.      "SWREL64",        /* name */
  1569.      false,            /* partial_inplace */
  1570.      MINUS_ONE,        /* src_mask */
  1571.      MINUS_ONE,        /* dst_mask */
  1572.      false),            /* pcrel_offset */
  1573.  
  1574.   /* A 32 bit reference to a symbol.  */
  1575.   HOWTO (ALPHA_R_REFLONG,    /* type */
  1576.      0,            /* rightshift */
  1577.      2,            /* size (0 = byte, 1 = short, 2 = long) */
  1578.      32,            /* bitsize */
  1579.      false,            /* pc_relative */
  1580.      0,            /* bitpos */
  1581.      complain_overflow_bitfield, /* complain_on_overflow */
  1582.      reloc_nil,        /* special_function */
  1583.      "REFLONG",        /* name */
  1584.      true,            /* partial_inplace */
  1585.      0xffffffff,        /* src_mask */
  1586.      0xffffffff,        /* dst_mask */
  1587.      false),        /* pcrel_offset */
  1588.  
  1589. };
  1590.  
  1591. /* Return a pointer to a howto structure which, when invoked, will perform
  1592.    the relocation code on data from the architecture noted.  */
  1593.  
  1594. static const struct reloc_howto_struct *
  1595. evax_bfd_reloc_type_lookup (abfd, code)
  1596.      bfd *abfd;
  1597.      bfd_reloc_code_real_type code;
  1598. {
  1599.   int alpha_type;
  1600.  
  1601. #if EVAX_DEBUG
  1602.   evax_debug (1, "evax_bfd_reloc_type_lookup(%p, %d)\t", abfd, code);
  1603. #endif
  1604.  
  1605.   switch (code)
  1606.     {
  1607.       case BFD_RELOC_16:        alpha_type = ALPHA_R_SREL16;    break;
  1608.       case BFD_RELOC_32:        alpha_type = ALPHA_R_REFLONG;    break;
  1609.       case BFD_RELOC_64:        alpha_type = ALPHA_R_REFQUAD;    break;
  1610.       case BFD_RELOC_CTOR:        alpha_type = ALPHA_R_REFQUAD;    break;
  1611.       case BFD_RELOC_23_PCREL_S2:    alpha_type = ALPHA_R_BRADDR;    break;
  1612.       case BFD_RELOC_ALPHA_HINT:    alpha_type = ALPHA_R_HINT;    break;
  1613.       case BFD_RELOC_16_PCREL:        alpha_type = ALPHA_R_SREL16;    break;
  1614.       case BFD_RELOC_32_PCREL:        alpha_type = ALPHA_R_SREL32;    break;
  1615.       case BFD_RELOC_64_PCREL:        alpha_type = ALPHA_R_SREL64;    break;
  1616.       case BFD_RELOC_ALPHA_LINKAGE:    alpha_type = ALPHA_R_LINKAGE;    break;
  1617.       case BFD_RELOC_SWREL32:        alpha_type = ALPHA_R_SWREL32;    break;
  1618.       case BFD_RELOC_SWREL64:        alpha_type = ALPHA_R_SWREL64;    break;
  1619. #if 0
  1620.       case ???:                alpha_type = ALPHA_R_OP_PUSH;    break;
  1621.       case ???:                alpha_type = ALPHA_R_OP_STORE;    break;
  1622.       case ???:                alpha_type = ALPHA_R_OP_PSUB;    break;
  1623.       case ???:                alpha_type = ALPHA_R_OP_PRSHIFT;break;
  1624.       case ???:                alpha_type = ALPHA_R_GPVALUE;    break;
  1625. #endif
  1626.       default:
  1627.     (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
  1628.     return (const struct reloc_howto_struct *) NULL;
  1629.     }
  1630. #if EVAX_DEBUG
  1631.   evax_debug (2, "reloc is %s\n", alpha_howto_table[alpha_type].name);
  1632. #endif
  1633.   return &alpha_howto_table[alpha_type];
  1634. }
  1635.  
  1636.  
  1637. /*-- Part 4.7, writing an object file ---------------------------------------*/
  1638.  
  1639. /* Set the architecture and machine type in BFD abfd to arch and mach.
  1640.    Find the correct pointer to a structure and insert it into the arch_info
  1641.    pointer.  */
  1642.  
  1643. static boolean
  1644. evax_set_arch_mach (abfd, arch, mach)
  1645.      bfd *abfd;
  1646.      enum bfd_architecture arch;
  1647.      unsigned long mach;
  1648. {
  1649. #if EVAX_DEBUG
  1650.   evax_debug (1, "evax_set_arch_mach(%p, %d, %ld)\n", abfd, arch, mach);
  1651. #endif
  1652.   abfd->arch_info = bfd_scan_arch("alpha");
  1653.  
  1654.   return true;
  1655. }
  1656.  
  1657.  
  1658. /* Sets the contents of the section section in BFD abfd to the data starting
  1659.    in memory at data. The data is written to the output section starting at
  1660.    offset offset for count bytes.
  1661.  
  1662.    Normally true is returned, else false. Possible error returns are:
  1663.    o bfd_error_no_contents - The output section does not have the
  1664.     SEC_HAS_CONTENTS attribute, so nothing can be written to it.
  1665.    o and some more too  */
  1666.  
  1667. static boolean
  1668. evax_set_section_contents (abfd, section, location, offset, count)
  1669.      bfd *abfd;
  1670.      asection *section;
  1671.      PTR location;
  1672.      file_ptr offset;
  1673.      bfd_size_type count;
  1674. {
  1675. #if EVAX_DEBUG
  1676.   evax_debug (1, "evax_set_section_contents(%p, sec %s, loc %p, off %ld, count %d)\n",
  1677.                     abfd, section->name, location, (long int)offset, (int)count);
  1678. #endif
  1679.   return _bfd_save_evax_section(abfd, section, location, offset, count);
  1680. }
  1681.  
  1682.  
  1683. /*-- Part 4.8, linker -------------------------------------------------------*/
  1684.  
  1685. /* Get the size of the section headers.  */
  1686.  
  1687. static int
  1688. evax_sizeof_headers (abfd, reloc)
  1689.      bfd *abfd;
  1690.      boolean reloc;
  1691. {
  1692. #if EVAX_DEBUG
  1693.   evax_debug (1, "evax_sizeof_headers(%p, %s)\n", abfd, (reloc)?"True":"False");
  1694. #endif
  1695.   return 0;
  1696. }
  1697.  
  1698.  
  1699. /* Provides default handling of relocation effort for back ends
  1700.    which can't be bothered to do it efficiently.  */
  1701.  
  1702. static bfd_byte *
  1703. evax_bfd_get_relocated_section_contents (abfd, link_info, link_order, data,
  1704.                      relocateable, symbols)
  1705.      bfd *abfd;
  1706.      struct bfd_link_info *link_info;
  1707.      struct bfd_link_order *link_order;
  1708.      bfd_byte *data;
  1709.      boolean relocateable;
  1710.      asymbol **symbols;
  1711. {
  1712. #if EVAX_DEBUG
  1713.   evax_debug (1, "evax_bfd_get_relocated_section_contents(%p, %p, %p, %p, %s, %p)\n",
  1714.             abfd, link_info, link_order, data, (relocateable)?"True":"False", symbols);
  1715. #endif
  1716.   return 0;
  1717. }
  1718.  
  1719.  
  1720. /* ???  */
  1721.  
  1722. static boolean
  1723. evax_bfd_relax_section (abfd, section, link_info, again)
  1724.      bfd *abfd;
  1725.      asection *section;
  1726.      struct bfd_link_info *link_info;
  1727.      boolean *again;
  1728. {
  1729. #if EVAX_DEBUG
  1730.   evax_debug (1, "evax_bfd_relax_section(%p, %s, %p, <ret>)\n",
  1731.                     abfd, section->name, link_info);
  1732. #endif
  1733.   return true;
  1734. }
  1735.  
  1736.  
  1737. /* Create a hash table for the linker.  Different backends store
  1738.    different information in this table.  */
  1739.  
  1740. static struct bfd_link_hash_table *
  1741. evax_bfd_link_hash_table_create (abfd)
  1742.      bfd *abfd;
  1743. {
  1744. #if EVAX_DEBUG
  1745.   evax_debug (1, "evax_bfd_link_hash_table_create(%p)\n", abfd);
  1746. #endif
  1747.   return 0;
  1748. }
  1749.  
  1750.  
  1751. /* Add symbols from this object file into the hash table.  */
  1752.  
  1753. static boolean
  1754. evax_bfd_link_add_symbols (abfd, link_info)
  1755.      bfd *abfd;
  1756.      struct bfd_link_info *link_info;
  1757. {
  1758. #if EVAX_DEBUG
  1759.   evax_debug (1, "evax_bfd_link_add_symbols(%p, %p)\n", abfd, link_info);
  1760. #endif
  1761.   return false;
  1762. }
  1763.  
  1764.  
  1765. /* Do a link based on the link_order structures attached to each
  1766.    section of the BFD.  */
  1767.  
  1768. static boolean
  1769. evax_bfd_final_link (abfd, link_info)
  1770.      bfd *abfd;
  1771.      struct bfd_link_info *link_info;
  1772. {
  1773. #if EVAX_DEBUG
  1774.   evax_debug (1, "evax_bfd_final_link(%p, %p)\n", abfd, link_info);
  1775. #endif
  1776.   return true;
  1777. }
  1778.  
  1779. /* Should this section be split up into smaller pieces during linking.  */
  1780.  
  1781. static boolean
  1782. evax_bfd_link_split_section (abfd, section)
  1783.      bfd *abfd;
  1784.      asection *section;
  1785. {
  1786. #if EVAX_DEBUG
  1787.   evax_debug (1, "evax_bfd_link_split_section(%p, %s)\n", abfd, section->name);
  1788. #endif
  1789.   return false;
  1790. }
  1791.  
  1792. /*-- Part 4.9, dynamic symbols and relocations ------------------------------*/
  1793.  
  1794. /* Get the amount of memory required to hold the dynamic symbols.  */
  1795.  
  1796. static long
  1797. evax_get_dynamic_symtab_upper_bound (abfd)
  1798.      bfd *abfd;
  1799. {
  1800. #if EVAX_DEBUG
  1801.   evax_debug (1, "evax_get_dynamic_symtab_upper_bound(%p)\n", abfd);
  1802. #endif
  1803.   return 0;
  1804. }
  1805.  
  1806. static boolean
  1807. evax_bfd_print_private_bfd_data (abfd, file)
  1808.     bfd *abfd;
  1809.     void *file;
  1810. {
  1811. #if EVAX_DEBUG
  1812.   evax_debug (1, "evax_bfd_print_private_bfd_data(%p)\n", abfd);
  1813. #endif
  1814.   return 0;
  1815. }
  1816.  
  1817.  
  1818. /* Read in the dynamic symbols.  */
  1819.  
  1820. static long
  1821. evax_canonicalize_dynamic_symtab (abfd, symbols)
  1822.      bfd *abfd;
  1823.      asymbol **symbols;
  1824. {
  1825. #if EVAX_DEBUG
  1826.   evax_debug (1, "evax_canonicalize_dynamic_symtab(%p, <ret>)\n", abfd);
  1827. #endif
  1828.   return 0L;
  1829. }
  1830.  
  1831.  
  1832. /* Get the amount of memory required to hold the dynamic relocs.  */
  1833.  
  1834. static long
  1835. evax_get_dynamic_reloc_upper_bound (abfd)
  1836.      bfd *abfd;
  1837. {
  1838. #if EVAX_DEBUG
  1839.   evax_debug (1, "evax_get_dynamic_reloc_upper_bound(%p)\n", abfd);
  1840. #endif
  1841.   return 0L;
  1842. }
  1843.  
  1844.  
  1845. /* Read in the dynamic relocs.  */
  1846.  
  1847. static long
  1848. evax_canonicalize_dynamic_reloc (abfd, arel, symbols)
  1849.      bfd *abfd;
  1850.      arelent **arel;
  1851.      asymbol **symbols;
  1852. {
  1853. #if EVAX_DEBUG
  1854.   evax_debug (1, "evax_canonicalize_dynamic_reloc(%p)\n", abfd);
  1855. #endif
  1856.   return 0L;
  1857. }
  1858.